﻿//#include <iostream>
//using namespace std;
////编译时递归返回条件，即递归终止函数
//void _func() { cout << endl; }
////注意: 递归返回条件不能使用下面的，因为出现无参函数时将会出错,即出现func()的情况
////template <class T>
////void _func(const T& data)
////{
////	cout << data << endl;
////}
//
////编译时递归解析，依次拿到参数包args里面的参数传递给T类型的data，
// 直到参数包args为空时调用递归终止函数_func()。
//template <class T, class... Args>
//void _func(const T& data, Args ...args)
//{
//	cout << data << " ";
//	_func(args...);
//}
//
////参数包args中有0-N个参数
//template <class ...Args>
//void func(Args ...args)
//{
//	_func(args...); //传入参数包
//}
//int main()
//{
//	func();
//	func(1);
//	func(1, 1, 1);
//	func(1, 1.2, "bit", 'a');
//	return 0;
//}

////编译阶段中，func(1, 1.2, 'a')在主函数传入模板被实例化后，将会推演生成以下类似的代码
//void func(int val1, double ch, char s)
//{
//	_func(val1, ch, s);
//}
////诼渐往下抽象递归解包参数，直到遍历到递归终止函数
//void _func(const int& data, double ch, char s)
//{
//	cout << data << " ";
//	_func(ch, s);
//}
//
//void _func(const double& data, char s)
//{
//	cout << data << " ";
//	_func(s);
//}
//
//void _func(const char& data)
//{
//	cout << data << " ";
//	_func(); //递归终止函数
//}

//template<size_t N>
//void fun()
//{
//	cout << N << " ";
//	fun<N - 1>();
//}
//
//template<>
//void fun<1>()
//{
//	cout << 1 << endl;
//}
//
//int main()
//{
//	fun<15000>();  //传入参数数量过大，递归层数过多，系统支撑不下
//	return 0;
//}

//#include <string>
//#include <list>
//#include <vector>
//#include "String.h"
//int main()
//{
//	list<bit::string> lt1;
//	bit::string s1("xxxx");
//	lt1.push_back(s1); //调用拷贝构造bit::string在容器中创建string对象
//	cout << endl;
//	lt1.push_back(move(s1)); //调用移动拷贝bit::string将资源转移到容器string对象中
//	cout << "=============================================" << endl;
//	//对象传递，没有临时对象的不必要拷贝，emplace_back的调用输出跟push_back一样
//	bit::string s2("xxxx");
//	lt1.emplace_back(s2);
//	cout << endl;
//	lt1.emplace_back(move(s2));
//	cout << "=============================================" << endl;
//	//先将"xxxx"构造成bit::string对象，然后拷贝到lt1容器中
//	lt1.push_back("xxxx");
//	cout << endl;
//	//直接在lt1容器中构造数据是"xxxx"的bit::string对象
//	lt1.emplace_back("xxxx");
//	cout << "=============================================" << endl;
//	list<pair<bit::string, bit::string>> lt2;
//	//下面输出两个重复的信息是因为pair是两个指令
//	pair<bit::string, bit::string> kv1("xxxx", "yyyy");
//	lt2.push_back(kv1);
//	lt2.push_back(move(kv1));
//	cout << "=============================================" << endl;
//
//	pair<bit::string, bit::string> kv2("xxxx", "yyyy");
//	//对象的传递，即便存储类型是pair键值对也是同理，与push_back输出一样
//	lt2.emplace_back(kv2);
//	lt2.emplace_back(move(kv2));
//	cout << "=============================================" << endl;
//	//注意:emplace的多参传入不能使用"{}"（初始化列表），主要是因为emplace函数不是通过列表初始化来构造对象的，而是使用直接初始化或拷贝初始化
//	lt2.emplace_back("xxxx", "yyyy");
//	cout << endl;
//	lt2.push_back({ "xxxx", "yyyy" });
//	cout << "=============================================" << endl;
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{
//		cout << "Date(int year, int month, int day)" << endl;
//	}
//	Date(const Date& d) //拷贝构造，没有移动语义
//		:_year(d._year)
//		, _month(d._month)
//		, _day(d._day)
//	{
//		cout << "Date(const Date& d)" << endl;
//	}
//private:
//	int _year = 1;
//	int _month = 1;
//	int _day = 1;
//};
//
//int main()
//{
//	list<Date> lt1;
//	lt1.push_back({ 2024,3,30 });
//	lt1.emplace_back(2024, 3, 30);
//	cout << endl;
//
//	//有名对象
//	Date d1(2023, 1, 1);
//	lt1.push_back(d1);
//	lt1.emplace_back(d1);
//	cout << endl;
//
//	//匿名对象
//	lt1.push_back(Date(2023, 1, 1));
//	lt1.emplace_back(Date(2023, 1, 1));
//	return 0;
//}